package Lamdemo;

import com.sun.xml.internal.ws.addressing.WsaActionUtil;

import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

//1无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
//2无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//3无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}
//4有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}

public class text {
    public static void main(String[] args) {
        HashMap<String,Integer> map = new HashMap<>();
        map.put("关羽",1);
        map.put("张飞",2);
        map.put("刘备",3);
        map.put("诸葛",4);
        //顺序是不一样的，他会通过自己第一个元素生成的哈希值进行排列
        System.out.println(map);
    }

    //Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读。
    //优点：
    //1. 代码简洁，开发迅速
    //2. 方便函数式编程
    //3. 非常容易进行并行计算
    //4. Java 引入 Lambda，改善了集合操作
    //缺点：
    //1. 代码可读性变差
    //2. 在非并行计算中，很多计算未必有传统的 for 性能要高
    //3. 不容易进行调试

    //map接口方法
    public static void main5(String[] args) {
        HashMap<Integer,String> map = new HashMap<>();
        map.put(1,"hello");
        map.put(2,"bit");
        map.put(3,"hello");
        map.put(4,"Lambda");

        //map的forEach需要重写BiConsumer
        //1.
        /*map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer integer, String s) {
                System.out.println("Key: "+integer+" Value: "+s);
            }
        });*/
        //2.简化
        map.forEach((integer, s) -> System.out.println("Key:"+integer+" Value:"+s));





    }


    //List接口方法
    public static void main4(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("bit");
        list.add("hello");
        list.add("lambda");


        //forEach表示调用一个，不带有参数的方法，其执行花括号内的语句，为原来的函数体内容。
        //简单遍历集合中的元素。
        //1.
        /*list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        //2.
        list.forEach(s -> System.out.println(s));



        //排序  sort方法源码：该方法根据c指定的比较规则对容器元素进行排序。
        //1.
        /*list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });*/
        //2.
        list.sort((o1,o2) -> o1.compareTo(o2));


        System.out.println("========");

        list.forEach(s -> System.out.println(s));
    }




    public static void main3(String[] args) {

        //有返回值

        //1.NoParameterReturn有返回值无参数
        //NoParameterReturn noParameterReturn = ()->{return 10;};
        NoParameterReturn noParameterReturn = ()->10;
        int ret = noParameterReturn.test();
        System.out.println(ret);

        //2.OneParameterReturn有返回值一个参数
        OneParameterReturn oneParameterReturn = b -> b+9;//参数是b返回b+9
        int ret2 = oneParameterReturn.test(10);
        System.out.println(ret2);

        //3.MoreParameterReturn有返回值多参数
        MoreParameterReturn moreParameterReturn = (a,b)-> a+b;
        int ret3 = moreParameterReturn.test(2,3);
        System.out.println(ret3);
    }

    public static void main2(String[] args) {

        //Lamdemo无返回值

        //1.NoParameterNoReturn无返回值无参数
        NoParameterNoReturn noParameterNoReturn = ()->System.out.println("test()....");
        noParameterNoReturn.test();
        //test()....

        //2.OneParameterNoReturn无返回值一个参数
        //OneParameterNoReturn oneParameterNoReturn = (int a)->{System.out.println(a+1);};
        //或者
        OneParameterNoReturn oneParameterNoReturn = a->System.out.println(a+1);;//因为就一个参数，所以可以省略
        oneParameterNoReturn.test(10);
        //11

        //3.MoreParameterNoReturn无返回值多个参数
        MoreParameterNoReturn moreParameterNoReturn = (a,b)-> System.out.println(a+b);
        moreParameterNoReturn.test(1,2);
        //3

    }

    public static void main1(String[] args) {
        int common = 10;
        //noParameterNoReturn无返回值无参数
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                //common = 99;//Lamdemo的变量捕获，匿名内部类当中不可以修改，使用时应看作常量或者不可以改变的量去计算
                //System.out.println(common);
                System.out.println("test()....");
            }
        };

        noParameterNoReturn.test();

        //1.Comparator
        /*PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });*/
        //2.Comparator
        PriorityQueue<Integer> priorityQueue2 = new PriorityQueue<>((o1,o2)->o1-o2);
    }
}
